#ifndef _THREAD_HPP__
#define _THREAD_HPP__
#include<pthread.h>
#include<string>
#include<functional>
#include <sys/types.h>
#include <unistd.h>
#include<iostream>


// namespace Thread
// {
//     static int number = 1;
//     enum class TSTATUS
//     {
//         NEW,
//         RUNNING,
//         STOP
//     };

//     template <typename T>
//     class myThread
//     {
//         using func_t = std::function<void(T&)>;
//     private:
//         // 成员方法！
//         static void *Routine(void *args)
//         {
//             myThread<T> *t = static_cast<myThread<T> *>(args);
//             t->_status = TSTATUS::RUNNING;
//             t->_func(t->_data);
//             return nullptr;
//         }
//         void EnableDetach() { _joinable = false; }

//     public:
//         myThread(func_t func, T &data) : _func(func), _data(data), _status(TSTATUS::NEW), _joinable(true)
//         {
//             _name = "Thread-" + std::to_string(number++);
//             _pid = getpid();
//         }
//         bool Start()
//         {
//             if (_status != TSTATUS::RUNNING)
//             {
//                 int n = ::pthread_create(&_tid, nullptr, Routine, this); // TODO
//                 if (n != 0)
//                     return false;
//                 return true;
//             }
//             return false;
//         }
//         bool Stop()
//         {
//             if (_status == TSTATUS::RUNNING)
//             {
//                 int n = ::pthread_cancel(_tid);
//                 if (n != 0)
//                     return false;
//                 _status = TSTATUS::STOP;
//                 return true;
//             }
//             return false;
//         }
//         bool Join()
//         {
//             if (_joinable)
//             {
//                 int n = ::pthread_join(_tid, nullptr);
//                 if (n != 0)
//                     return false;
//                 _status = TSTATUS::STOP;
//                 return true;
//             }
//             return false;
//         }
//         void Detach()
//         {
//             EnableDetach();
//             pthread_detach(_tid);
//         }
//         bool IsJoinable() { return _joinable; }
//         std::string Name() { return _name; }
//         ~myThread()
//         {
//         }

//     private:
//         std::string _name;
//         pthread_t _tid;
//         pid_t _pid;
//         bool _joinable; // 是否是分离的，默认不是
//         func_t _func;
//         TSTATUS _status;
//         T &_data;
//     };
// };
// namespace Thread
// {
//    //verson 2 
//     static int number=1;
//     enum class STATUS
//     {
//         NEW,
//         RUNING,
//         STOP
//     };
//     const char* to_str(STATUS status) {
//     switch (status) {
//         case STATUS::NEW: return "NEW";
//         case STATUS::RUNING: return "RUNING"; 
//         case STATUS::STOP: return "STOP";
//         default: return "UNKNOWN";
//     }
//    }
//      std::ostream& operator<<(std::ostream& os, STATUS status) {
//         return os << to_str(status);
//      }
//     template<class T>
//     class  myThread
//     {
//       using fun_c = std::function<void(T&)>;
//       private:
//       //Routine 必须写成类里的静态函数 因为如果是类成员函数会默认有this指针
//       //Routine（myThread* this,void* args）
//       static void* Routine(void* args)
//       {
//         std::cout<<"进入Routinue"<<std::endl;
//         myThread<T>* thisthd = static_cast<myThread<T> *>(args);
//         thisthd->_status=STATUS::RUNING;
//         thisthd->_fun(thisthd->_data);
       
//         return nullptr;
//       }
//       public:
//       myThread(fun_c fun,T& data)
//       :_fun(fun)
//       ,_joinenable(true)
//       ,_status(STATUS::NEW)
//       ,_data(data)
//       {
//         _name="Thread" + std::to_string(number++);
//         _pid=getpid();
        
        
//       }
//       bool Start()
//       {
      
//             if(_status == STATUS::NEW)
//             {
//                 std::cout<<"进入strat"<<std::endl;
//                 int n = pthread_create(&_tid,nullptr,Routine,this);
//                 if(n != 0)
//                 {
//                     std::cout<<"创建线程失败"<<std::endl;
//                     return false;
//                 }
//                 std::cout<<"创建成功"<<n<<std::endl;
//                 return true; 
//             }
//             return false;
      
//       }
//       bool Join()
//       {
//         if(_joinenable&&_status==STATUS::RUNING)
//         {
//             int n  = pthread_join(_tid,nullptr);
//             if(n!=0)
//             {
//                 std::cout<<"等待线程失败1"<<std::endl;
//                 return false;
//             }
//             //join住了线程就要终止了
//             _status= STATUS::STOP;
//             return true;
//         }
//         std::cout<<"等待线程失败2"<<"join"<<_joinenable<<" _stauts"<<_status<<std::endl;
//         return false;
//       }
//       bool Stop()
//       {
//             if(_status==STATUS::RUNING)
//             {
//                 int n = pthread_cancel(_tid);
//                 if(n != 0)
//                 {
//                     std::cout<<"终止线程失败"<<std::endl;
//                     return false;
//                 }
//                 _status=STATUS::STOP;
//                 return true;
//             }
//             return false;
//       }
//       void Detach()
//       {
//         _joinenable=false;
//         pthread_detach(_tid);
//       }
//       std::string Name()
//       {
//         return _name;
//       }
//       bool isJoin()//等待的状态 // 是否可以分离
//       {
//         return _joinenable;
//       }

//      private:
//         std::string _name;
//         pthread_t _tid;//线程的tid
//         pid_t _pid;//进程的pid
//         bool _joinenable;//是否被等待回收  默认是被等待 或 可不可以分离 否  
//         fun_c _fun;
//         STATUS _status;
//         T& _data;
//     };



// };























namespace Thread
{
    using fun_c = std::function<void(std::string name)>;
    static int number=1;
    enum class STATUS
    {
        NEW,
        RUNING,
        STOP
    };
    class  myThread
    {
     private:


      public:
      //Routine 必须写成类里的静态函数 因为如果是类成员函数会默认有this指针
      //Routine（myThread* this,void* args）
      static void* Routine(void* args)
      {
        myThread* thisthd = static_cast<myThread*>(args);
        thisthd->_status=STATUS::RUNING;
        thisthd->_fun(thisthd->Name());
       
        return nullptr;
      }
      myThread(fun_c fun)
      :_fun(fun)
      ,_joinenable(true)
      ,_status(STATUS::NEW)
      {
        _name="Thread" + std::to_string(number++);
        _pid=getpid();
      }
      bool Start()
      {
            if(_status == STATUS::NEW)
            {
                int n = pthread_create(&_tid,nullptr,Routine,this);
                if(n != 0)
                {
                    std::cout<<"创建线程失败"<<std::endl;
                    return false;
                }
                 return true; 
            }
            return false;
      
      }
      bool Join() //等待线程结束并回收
      {
        if(_joinenable&&_status==STATUS::RUNING)
        {
            int n  = pthread_join(_tid,nullptr);
            if(n!=0)
            {
                std::cout<<"等待线程失败"<<std::endl;
                return false;
            }
            //join住了线程就要终止了
            _status= STATUS::STOP;
            return true;
        }
        return false;
      }
      bool Stop()
      {
            if(_status==STATUS::RUNING)
            {
                int n = pthread_cancel(_tid);
                if(n != 0)
                {
                    std::cout<<"终止线程失败"<<std::endl;
                    return false;
                }
                _status=STATUS::STOP;
                return true;
            }
            return false;
      }
      void Detach()
      {
        _joinenable=false;
        pthread_detach(_tid);
      }
      std::string Name()
      {
        return _name;
      }
      bool isJoin()//等待的状态 // 是否可以分离
      {
        return _joinenable;
      }

     private:
        std::string _name;
        pthread_t _tid;//线程的tid
        pid_t _pid;//进程的pid
        bool _joinenable;//是否被等待回收  默认是被等待 或 可不可以分离 否  
        fun_c _fun;
        STATUS _status;
    };



};

#endif